/**
 * @file gestiondefichier.c
 * @author Florian Castellane <florian.castellane@grenoble-inp.org>
 * @author Christian Proust <christian.proust@phelma.grenoble-inp.fr>
 * @date Tue Sep 25 01:04:00 2012
 * @brief Fonctions de gestion de fichiers.
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "include/gestiondefichier.h"
#include "include/analyselexicale.h"
#include "include/gestiondetypes.h"
#include "include/gestiondesmessages.h"
#include "include/analysesyntaxique.h"

FILE * ouvrir_fichier(const char * nom_de_fichier, const char* mode)
{
    FILE * fichier=NULL;

    /// PARTIE 1 : on ouvre le fichier
    fichier = fopen(nom_de_fichier,mode);

    /// Partie 2 : on verifie que l'ouverture s'est bien deroule
    if(fichier==NULL)
    {
        perror("Erreur d\'ouverture de fichier");
        ecriremessage(NIVEAU_ERROR, "Erreur d\'ouverture du fichier <%s> .\n", nom_de_fichier);
        exit(EXIT_FAILURE);
    }
    return fichier;
}

LISTE recuperer_source_assembleur (char *nom_fichier_source)
{
    unsigned int num_ligne=0;


    /////////////////////////////////////////////////
    // INITIALISATION                              //
    /////////////////////////////////////////////////
    char une_ligne_du_fichier[TAILLE_MAX_LIGNE*3+1];
    LISTE liste_de_lexemes=creer_liste();              // crée une liste vide (NULL)
    FILE *fichier_a_lire=ouvrir_fichier(nom_fichier_source,"r");
    verif_taille_fichier(fichier_a_lire,TAILLE_MAX_LIGNE);
    /////////////////////////////////////////////////

    while( fgets(une_ligne_du_fichier,TAILLE_MAX_LIGNE,fichier_a_lire)!=NULL )  // ligne par ligne jusqu'à la fin du fichier
    {
//        ecriremessage(NIVEAU_DEBUG,"Ligne %03d avant canonisation:\t%s",num_ligne+1,une_ligne_du_fichier);
        canoniser_ligne(une_ligne_du_fichier);
//        ecriremessage(NIVEAU_DEBUG,"Ligne %03d apres canonisation:\t%s",num_ligne+1,une_ligne_du_fichier);
        num_ligne++;
        liste_de_lexemes = decoupe_ligne_lexeme(une_ligne_du_fichier,liste_de_lexemes, num_ligne);
    }
    ecriremessage(NIVEAU_INFO,"%d ligne(s) du fichier ASM a (ont) %ct%c lue(s).\n",num_ligne, E_ACCENTAIGU, E_ACCENTAIGU);

    liste_de_lexemes = classifie_liste_lexeme(liste_de_lexemes);

    fclose(fichier_a_lire);
    return liste_de_lexemes;
}

int verif_taille_fichier(FILE *fichier, int taille_max_ligne)
{

    int i, Max;// La taille max d'une ligne de fichier doit etre inferieure a
    //ce qu'un int peut compter
    int nombre_de_ligne=0;
    char lettre=0;


    /// PARTIE 1 : On cherche le nombre de caracteres max par ligne du fichier
    Max = i = 0; //Max est le nombre de charactere max et i le nombre lu

    while(fscanf(fichier,"%c",&lettre)!=EOF)
    {
        if (lettre =='\n')
        {
            if(i>Max) Max=i;
            i=0;
            nombre_de_ligne ++;
        }
        else
        {
            i++;
        }
    }

    ///PARTIE 2 : on s'assure que le nombre de caractere est inferieur au seuil

    if(taille_max_ligne < Max)
    {
        ecriremessage(NIVEAU_ERROR,"Le nombre de caractere par ligne du fichier depasse est plus grand que %d.", taille_max_ligne);
        exit(EXIT_FAILURE);
    }


    fseek(fichier,0,SEEK_SET);//on retourne le curseur au debut pour le reste du programme
    return nombre_de_ligne;
}

INSTRUCTION * recuperer_instruction(char *nom_fichier_source)
{
    int nb_lignes_lues=0;
    int i=0, j=0;


    /////////////////////////////////////////////////
    // INITIALISATION                              //
    /////////////////////////////////////////////////
    char une_ligne_du_fichier[TAILLE_MAX_LIGNE];
    char delimiteur[]=" ";
    char nom_instruction[TAILLE_MAX_INSTRUCTION];
    FILE *fichier_a_lire=ouvrir_fichier(nom_fichier_source,"r");
    int nb_de_ligne=verif_taille_fichier(fichier_a_lire,TAILLE_MAX_LIGNE);
    INSTRUCTION* t_instruction = calloc(nb_de_ligne+1,sizeof(INSTRUCTION)); // la dernière case est laissée vide afin de libérer l'intérieur des cases du tableau

    /////////////////////////////////////////////////

    while( fgets(une_ligne_du_fichier,TAILLE_MAX_LIGNE,fichier_a_lire)!=NULL )  // ligne par ligne jusqu'à la fin du fichier
    {
        canoniser_ligne(une_ligne_du_fichier);

        sscanf(strtok(une_ligne_du_fichier,delimiteur), "%s", nom_instruction);
        sscanf(strtok(NULL,delimiteur), "%d", &((t_instruction[nb_lignes_lues]).nb_op) );
        sscanf(strtok(NULL,delimiteur), "%d", &((t_instruction[nb_lignes_lues]).type));
        sscanf(strtok(NULL,delimiteur), "%s", ((t_instruction[nb_lignes_lues]).type_operande));
        sscanf(strtok(NULL,delimiteur), "%d", &((t_instruction[nb_lignes_lues]).nb_param));
        //sscanf de nom & nb_op & type & type_operande & nb_param
        (t_instruction[nb_lignes_lues]).nom = strdup(nom_instruction);
        if (!t_instruction[nb_lignes_lues].nom)
        {
            // Allocation dynamique echoue
            ecriremessage(NIVEAU_ERROR, "Allocation dynamique du dictionnaire d'intruction echouee.\n");
            exit(EXIT_FAILURE);
        }

        if (t_instruction[nb_lignes_lues].type !=7)
        {
            //si c'est pas une pseudo-instruction
            sscanf(strtok(NULL,delimiteur), "%x",&(t_instruction[nb_lignes_lues].cache));
            //sscanf de cache
            for (i=0; i<t_instruction[nb_lignes_lues].nb_param; i++)
            {
                sscanf(strtok(NULL,delimiteur),"%d",&t_instruction[nb_lignes_lues].position_parametre[i]);
            }//sscanf de position_parametre
            for (i=0; i<t_instruction[nb_lignes_lues].nb_param; i++)
            {
                sscanf(strtok(NULL,delimiteur),"%d",&t_instruction[nb_lignes_lues].taille_parametre[i]);
            }//sscanf de taille_parametre
        }
        else
        {
            //si c'est une pseudo instruction
            t_instruction[nb_lignes_lues].chaine_instruction = (int*)\
                    calloc(t_instruction[nb_lignes_lues].nb_param, sizeof(int));
            t_instruction[nb_lignes_lues].valeur_operande = (int**)\
                    allouer_matrice( t_instruction[nb_lignes_lues].nb_param, NOMBRE_MAX_D_OPERANDES ,sizeof(int));
            if (!t_instruction[nb_lignes_lues].chaine_instruction || !t_instruction[nb_lignes_lues].valeur_operande)
            {
                // Allocation dynamique echoue
                ecriremessage(NIVEAU_ERROR, "Allocation dynamique du dictionnaire d'intruction echouee.\n");
                exit(EXIT_FAILURE);
            }

            for (i=0; i<t_instruction[nb_lignes_lues].nb_param; i++)
            {
                sscanf(strtok(NULL,delimiteur),"%s", nom_instruction);

                t_instruction[nb_lignes_lues].chaine_instruction[i]= (int)\
                        identif_instruction(t_instruction, nom_instruction,0);
                //attribution de chaine_instruction

                for (j=0; j< ( t_instruction[ t_instruction[nb_lignes_lues].chaine_instruction[i] ].nb_op  /10); j++)
                {
                    sscanf(strtok(NULL,delimiteur), "%d", &t_instruction[nb_lignes_lues].valeur_operande[i][j]);
                }//attribution de valeur_operande

            }
        }


        nb_lignes_lues++;

    }
    (t_instruction[nb_de_ligne]).type = 0;

    ecriremessage(NIVEAU_INFO,"%d ligne(s) du dictionnaire d'instructions ASM a (ont) ete lue(s).\n",nb_lignes_lues);

    fclose(fichier_a_lire);
    return t_instruction;
}

void visualiser_dictionnaire_instruction( INSTRUCTION dictionnaire_instruction[] )
{
    int i;
    ecriremessage(NIVEAU_INFO, "Visualisation du dictionnaire d'instructions :\n");
    for (i=0; (dictionnaire_instruction[i]).type != 0 ; i++)
    {
        ecriremessage(NIVEAU_INFO,"instruction %03d : <<%4s>>\t<<%2d>>\t<<%d>>\t<%3s>\t<%d>\t<OX%.8X>\n", \
                      i+1,(dictionnaire_instruction[i]).nom,(dictionnaire_instruction[i]).nb_op,
                      (dictionnaire_instruction[i]).type, (dictionnaire_instruction[i]).type_operande \
                      ,(dictionnaire_instruction[i]).nb_param  ,(dictionnaire_instruction[i]).cache  );
        /*
        	    char *nom;// allocation dynamique
                    int nb_op;  // Le chiffre des dizaine est le nombre d'opérande et celui des unité
                    //est le nombre d'opérande qui sont des registres

                    int type;
                    char type_operande[NOMBRE_MAX_D_OPERANDES+1];       // Lettre reperant le type de chaque operande '$' pour registre 'I' pour immediate
                    //'N' pour adressage indirect 'O' pour offset et 'T' pour target, 'S' pour sa
                    // ::: $INOTS
                    int nb_param;//en cas de pseudo-instruct : taille de chaine_instruct

                ////////Hors pseudo instruction//////

                unsigned int cache;//NULL en cas de pseudo-instruct
                int position_parametre[NOMBRE_MAX_D_OPERATEURS];//NULL en cas de pseudo-instruct
                int taille_parametre[NOMBRE_MAX_D_OPERATEURS];//NULL en cas de pseudo-instruct

                ////////Pseudo instruction////////////

                int *chaine_instruction;    //On a une chaine allouee dynamiquement, de numero d'instruction precedants
                //Les pseudos-instructions doivent etre en fin de dico
                int **valeur_operande;// matrice de (nb_param) colonnes et NOMBRE_MAX_D_OPERANDES lignes allouees dynamiquement
        */
    }
}


void imprimer_l(char *nom_du_fichier, LIGNE_INSTRUCT_ASM * text, LIGNE_DIRECTIVE_ASM * data, LISTE source, LISTE l_etq)
{
    unsigned int ligne_source=1;
    unsigned int ligne_objet=0;
    unsigned int i=0;
    LISTE index = source;
    FILE * fichier = ouvrir_fichier(nom_du_fichier, "w+");

    ecriremessage(NIVEAU_INFO, "Ecriture dans le fichier %s de la liste d'assemblage...\n", nom_du_fichier);

    for (ligne_source = 1; !est_vide(index); ligne_source ++)
    {
        ligne_objet = 0;

        fprintf(fichier,"%3d ",ligne_source);
        ecriremessage(NIVEAU_DEBUG, "Ecriture de la ligne %3d du code source dans la liste d'assemblage.\n",ligne_source);
        for (i=0; text[i].num_instruction !=-1; i++) //tant qu'on a pas atteint la fin du tableau de text
        {
            ligne_objet += imprimer_text(text[i], ligne_source, ligne_objet, i, fichier);
            index = imprimer_source(ligne_objet, index, fichier);
        }


		for (i=0; data[i].directive >-1; i++) //tant qu'on a pas atteint la fin du tableau de text
		{
			ligne_objet += imprimer_data(data[i], ligne_source, ligne_objet, i, fichier);
			index = imprimer_source(ligne_objet, index, fichier);
		}

        ligne_objet = -(ligne_objet +1);
        index = imprimer_source(ligne_objet, index, fichier);
        fprintf(fichier,"\n");
    }

    imprimer_etq(l_etq, fichier);

    fclose(fichier);
}


void imprimer_etq(LISTE etq, FILE *fichier)
{
    LISTE index;
    for (index = etq; !est_vide(index); index = index->suivant)
    {
        if ( ((ELEMENT_ETIQUETTE *)(index->element))->type == 0 )
        {
            fprintf(fichier,"\n[NON DEFINIE] \t\t %s",((ELEMENT_ETIQUETTE *)(index->element))->nom);
        }

        if ( ((ELEMENT_ETIQUETTE *)(index->element))->type < 0 )
        {
            fprintf(fichier,"\n.data : 0x%.8X \t %s",((ELEMENT_ETIQUETTE *)(index->element))->num_ligne*4\
                    ,((ELEMENT_ETIQUETTE *)(index->element))->nom);
        }

        if ( ((ELEMENT_ETIQUETTE *)(index->element))->type > 0 )
        {
            fprintf(fichier,"\n.text : 0x%.8X \t %s",((ELEMENT_ETIQUETTE *)(index->element))->num_ligne*4\
                    ,((ELEMENT_ETIQUETTE *)(index->element))->nom);
        }
    }
}

int imprimer_text(LIGNE_INSTRUCT_ASM text, int numero_source, int numero_ASM, int indice, FILE *fichier)
{

    if ( text.num_ligne_source == numero_source)
    {
        if (numero_ASM >= 1)
        {
            fprintf(fichier,"\n%3d ", numero_source);
        }
        fprintf(fichier, " 0x%.4X\tOx%.8X \t",4*indice, text.code_final);
        return 1;
    }
    return 0;
}

int imprimer_data(LIGNE_DIRECTIVE_ASM data, int numero_source, int numero_ASM, int indice, FILE *fichier)
{
	int i;

    if ( ((ELEMENT_LEXEME*)(data.tab_liste[0]->element))->num_ligne_lexeme == (unsigned int)numero_source)
    {
        switch (data.directive) {
			case TYPE_WORD:
				fprintf(fichier,"0x%.4X\t",data.adresse_ligne);

				if (data.nombre_de_valeurs>1)
				{
					for (i=0; i<data.nombre_de_valeurs; i++)
					{
						if (i%5==4)
						{
							fprintf(fichier,"\n%3d 0x%.4d\t", numero_source, data.adresse_ligne+4*i);
						}
						fprintf(fichier,"0x%.8lX\t",data.chaine_valeur[i]);

					}
					fprintf(fichier,"\n%3d\t\t\t\t",numero_source);
				}
				else
				{
					fprintf(fichier,"0x%.8lX\t",data.chaine_valeur[0]);
				}

				break;

			case TYPE_BYTE:
				fprintf(fichier,"0x%.4X\t",data.adresse_ligne);

				if (data.nombre_de_valeurs>4)
				{
					for (i=0; i<data.nombre_de_valeurs; i++)
					{
						if (i%12==11)
						{
							fprintf(fichier,"\n%3d 0x%.4d\t", numero_source, data.adresse_ligne+i);
						}
						fprintf(fichier,"0x%.2X\t",data.chaine_valeur[i]);

					}
					fprintf(fichier,"\n%3d\t\t\t\t",numero_source);
				}
				else
				{
					fprintf(fichier,"0x");
					for (i=0; i<data.nombre_de_valeurs; i++)
						fprintf(fichier,"%.2lX",data.chaine_valeur[i]);
					fprintf(fichier,"\t");
				}



				break;

			case TYPE_SPACE:
				fprintf(fichier,"0x%.4X\t",data.adresse_ligne);
				fprintf(fichier,"Ox");
				for (i=0; i<2*data.chaine_valeur[0]; i++)
				{
					fprintf(fichier,"0");
					if (i%30==29)
					{
						fprintf(fichier,"\n%3d 0x%.4d\t0x", numero_source, data.adresse_ligne+4*i);
					}
				}
				fprintf(fichier,"\n%3d\t\t\t\t",numero_source);

					break;

			default:
				break;
		}
        return 1;
    }
    return 0;
}

LISTE imprimer_source(int numero_objet, LISTE source, FILE *fichier)
{

    LISTE index = source;
//	ecriremessage(NIVEAU_DEBUG,"Blop : %s \t%d\n",((ELEMENT_LEXEME*)(index->element))->chaine_lexeme, numero_objet);
    if (numero_objet == 1)
    {
        // Dans le cas ou l'on a une intruction possedant une ligne de code ASM
        for (index = source; !est_vide(index); index=index->suivant)
        {
//			ecriremessage(NIVEAU_DEBUG, "Ecriture dans le fichier .l de : %s\n",((ELEMENT_LEXEME*)(index->element))->chaine_lexeme);

            if ( ((ELEMENT_LEXEME*)(index->element))->type_de_lexeme == TYPE_Nouvelle_ligne )
            {
                //fprintf(fichier,"\n");
                //index = index->suivant;
                break;
            }
            fprintf(fichier,"%s ", ((ELEMENT_LEXEME*)(index->element))->chaine_lexeme);
        }
    }
    if (numero_objet == -1)
    {
        //Dans le cas ou l'on a une instruction ne possedant pas de code ASM
        fprintf(fichier, "   \t \t\t\t");
        for (index = source; !est_vide(index); index=index->suivant)
        {
//			ecriremessage(NIVEAU_DEBUG, "Ecriture dans le fichier .l de : %s\n",((ELEMENT_LEXEME*)(index->element))->chaine_lexeme);

            if ( ((ELEMENT_LEXEME*)(index->element))->type_de_lexeme == TYPE_Nouvelle_ligne )
            {
                //fprintf(fichier,"\n");
                break;
            }
            fprintf(fichier,"%s ", ((ELEMENT_LEXEME*)(index->element))->chaine_lexeme);
        }
    }
    if (numero_objet <=-3)
    {
        //Dans le cas ou l'on a une instruction possedant plusieurs lignes de code ASM
        //fprintf(fichier,"\n");
    }
    if (est_vide(index))
    {
        return index;
    }
    if (numero_objet<0)
    {
        return index->suivant;
    }
    return index;
}

char * changer_extension_fichier(char * nom_source,char *ext)   // le code original a du mal sous windows ou avec des noms bizarres, je l'adapte : par exemple miam.s donnera miam.s.ext
{
    char *sortie;
/*    if ( (nom_source[strlen(nom_source) -1 ] != 's') \
            &&  (nom_source[strlen(nom_source) -2 ] != '.')      )
    {
        sortie = malloc(strlen(nom_source)+strlen(ext));

        if (!sortie)
        {
            printf("Erreur : Allocation dynamique echoue (le nom de fichier de depart est sans doute trop grand");
            exit(EXIT_FAILURE);
        }
        strcpy(sortie,nom_source);
        strcat(sortie,ext);
        return(sortie);
    }   */

    sortie = malloc(strlen(nom_source)+strlen(ext));

    if (!sortie)
    {
        printf("Erreur : Allocation dynamique echouee dans %s:changer_extension_fichier ligne %d (le nom de fichier de depart pourrait etre trop grand", __FILE__, __LINE__);
        exit(EXIT_FAILURE);
    }
    sortie=strcpy(sortie, nom_source);
    sortie=strcat(sortie,ext);
    return(sortie);
}

void imprimer_obj(char *nom_du_fichier, LIGNE_INSTRUCT_ASM * text, LIGNE_DIRECTIVE_ASM * data)
{
    int ligne_source, i,j,init_data, position_data;
	position_data = 0;
	unsigned char zero = '0', byte_a_imprimer,byte_inter;
    FILE * fichier = ouvrir_fichier(nom_du_fichier, "w+");
    unsigned int code_a_imprimer, code_inter;
    ecriremessage(NIVEAU_INFO, "Ecriture dans le fichier %s du code binaire...\n", nom_du_fichier);

	code_inter = 0;
    code_a_imprimer = ( (code_inter >> 24) & 0X000000FF )  +  ( (code_inter >> 8) & 0X0000FF00 ) + ( (code_inter << 8) & 0X00FF0000 ) + ( (code_inter << 24) & 0XFF000000 ) ;
    fwrite(&code_a_imprimer, sizeof(unsigned int), 1, fichier);
	code_inter = taille_text(text);
    code_a_imprimer = ( (code_inter >> 24) & 0X000000FF )  +  ( (code_inter >> 8) & 0X0000FF00 ) + ( (code_inter << 8) & 0X00FF0000 ) + ( (code_inter << 24) & 0XFF000000 ) ;
    fwrite(&code_a_imprimer, sizeof(unsigned int), 1, fichier);



    for (i=0; text[i].num_instruction !=-1; i++) //tant qu'on a pas atteint la fin du tableau de text
    {
        code_inter = text[i].code_final;
        code_a_imprimer = ( (code_inter >> 24) & 0X000000FF )  +  ( (code_inter >> 8) & 0X0000FF00 ) + ( (code_inter << 8) & 0X00FF0000 ) + ( (code_inter << 24) & 0XFF000000 ) ;
        fwrite(&code_a_imprimer, sizeof(unsigned int), 1, fichier);
		//printf("\n.text: %X  /// code_inter = %X ( (code_inter >> 8) & 0X0000FF00 )= %x\t (code_inter >> 24) = %x\n",code_a_imprimer, code_inter, ( (code_inter >> 8) & 0X0000FF00 )  , code_inter >> 24) ;
        //ligne_objet += imprimer_text(text[i], ligne_source, ligne_objet, i, fichier);
        //index = imprimer_source(ligne_objet, index, fichier);
    }

	init_data = ftell(fichier);
	code_inter = 0;
    code_a_imprimer = ( (code_inter >> 24) & 0X000000FF )  +  ( (code_inter >> 8) & 0X0000FF00 ) + ( (code_inter << 8) & 0X00FF0000 ) + ( (code_inter << 24) & 0XFF000000 ) ;
    fwrite(&code_a_imprimer, sizeof(unsigned int), 1, fichier);
	code_inter = taille_data(text);
    code_a_imprimer = ( (code_inter >> 24) & 0X000000FF )  +  ( (code_inter >> 8) & 0X0000FF00 ) + ( (code_inter << 8) & 0X00FF0000 ) + ( (code_inter << 24) & 0XFF000000 ) ;
    fwrite(&code_a_imprimer, sizeof(unsigned int), 1, fichier);


	for (i=0; data[i].directive >-1; i++) //tant qu'on a pas atteint la fin du tableau de data
    {
		switch (data[i].directive)
		{
			case TYPE_WORD:
				while ((position_data) % 4 ==0 )
				{//reallignement
					fwrite(&zero,sizeof(char),1,fichier);
					position_data ++;
				}
				for (j=0; j<data[i].nombre_de_valeurs; j++)
				{
					code_inter = (unsigned int)(data[i].chaine_valeur[j]);
					code_a_imprimer = ( (code_inter >> 24) && 0X000000FF )  +  ( (code_inter >> 8) && 0X0000FF00 ) + ( (code_inter << 8) && 0X00FF0000 ) + ( (code_inter << 24) && 0XFF000000 ) ;
					fwrite(&code_a_imprimer, sizeof(unsigned int), 1, fichier);
				//printf("\n.word :%X\n",code_a_imprimer);
					position_data +=4;
				}
				break;
			case TYPE_BYTE:
				for (j=0; j<data[i].nombre_de_valeurs; j++)
				{
					byte_a_imprimer = (unsigned char)(data[i].chaine_valeur[j]);

					/*if (position_data%4 !=0)
					{
						fseek(fichier,-1, SEEK_CUR);
					}
					else
					{
						fseek(fichier,0,SEEK_END);
					}*/
					fwrite(&byte_a_imprimer,sizeof(unsigned char),1,fichier);
					position_data++;
					//printf("\n.byte :%X\n",byte_a_imprimer);
				}
				break;

			case TYPE_SPACE:
				code_inter = (unsigned int)(data[i].chaine_valeur[0]);
				for (j=0; j<code_inter; j++)
				{
					/*
					if (position_data%4 !=0)
					{
						fseek(fichier,-1, SEEK_CUR);
					}
					else
					{
						fseek(fichier,0,SEEK_END);
					}*/
					fwrite(&zero,sizeof(unsigned char),1,fichier);
					position_data++;
					//printf("\n.space :%X\n",0);
				}



			default:
				break;




		}
    }

    fclose(fichier);
}

long int taille_text(LIGNE_INSTRUCT_ASM * text)
{
	long int i;
  	for (i=0; text[i].num_instruction !=-1; i++);

	return i;
}

long int taille_data(LIGNE_DIRECTIVE_ASM * data)
{
	long int i, taille;
	taille = 0;
	for (i=0; data[i].directive >0 && data[i].directive<NOMBRE_TYPE_DIRECTIVE; i++)
	{
 		switch (data[i].directive)
		{
			case TYPE_WORD:
				taille += 1;
				break;
			case TYPE_BYTE:
				taille += 4;
				break;
			case TYPE_SPACE:
				taille += data[i].chaine_valeur[0];
				break;
			default:
				ecriremessage(NIVEAU_ERROR,"Erreur dans taille_data : type = %d",data[i].directive);
				exit(EXIT_FAILURE);
		}
	}
	return taille;
}
